home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / kernel / dev / sun4.md / devXbusTest.c < prev    next >
C/C++ Source or Header  |  1992-12-18  |  9KB  |  373 lines
  1. /* 
  2.  * devXbusTest.c --
  3.  *
  4.  *    Routines for testing the xbusboard.
  5.  *
  6.  * Copyright 1991 Regents of the University of California
  7.  * Permission to use, copy, modify, and distribute this
  8.  * software and its documentation for any purpose and without
  9.  * fee is hereby granted, provided that the above copyright
  10.  * notice appear in all copies.  The University of California
  11.  * makes no representations about the suitability of this
  12.  * software for any purpose.  It is provided "as is" without
  13.  * express or implied warranty.
  14.  */
  15.  
  16. #ifndef lint
  17. static char rcsid[] = "$Header: /cdrom/src/kernel/Cvsroot/kernel/dev/sun4.md/devXbusTest.c,v 9.1 92/10/23 15:04:33 elm Exp $ SPRITE (Berkeley)";
  18. #endif /* not lint */
  19.  
  20. #include "sprite.h"
  21. #ifndef TESTING
  22. #include "stdio.h"
  23. #include "mach.h"
  24. #include "dev.h"
  25. #include "devInt.h"
  26. #include "stdlib.h"
  27. #include "vmMach.h"
  28. #include "dev/xbus.h"
  29. #include "devXbusInt.h"
  30. #include "devXbus.h"
  31. #include "dbg.h"
  32. #include "sync.h"
  33. #endif
  34.  
  35. #ifdef TESTING
  36. typedef int Sync_Semaphore;
  37.  
  38. #define Sync_SemInitStatic(name)    1
  39. #define FS_WRITE    2
  40. #endif
  41.  
  42. extern int    devXbusDebug;
  43. static int    xbusID = 0xd;
  44. static int    hppiID = 0;
  45.  
  46. static int    hppiQueue[1000];
  47. static int    numInHppiQueue = 0;
  48. static int    hppiInUse = 0;
  49. static Sync_Semaphore hppiMutex = Sync_SemInitStatic("MyHppiIO\n");
  50.  
  51. static int    bufStartAddr;
  52. static int    bufEndAddr;
  53. static int    suSize;
  54. static int    numDisk;
  55. static int    bufSize;
  56. static int    dataBufSize;
  57. static int    numBuf;
  58. static int    sectorsPerStripe;
  59.  
  60. static Sync_Semaphore    mutex = Sync_SemInitStatic("devXbusTest.c");
  61. static int    hppiQueued = 0;
  62. static int    xorQueued = 0;
  63. static int    diskQueued = 0;
  64. static int    numReq = 0;
  65.  
  66. #define DataAddress(reqID) (bufStartAddr + (reqID) * bufSize)
  67. #define ParityAddress(reqID) (DataAddress(reqID) + dataBufSize)
  68.  
  69. static void myHppiCallback();
  70. static void hppiCallback();
  71. static void xorCallback();
  72. static void diskCallback();
  73.  
  74. #ifdef TESTING
  75. int raidArray[1];
  76.  
  77. static int masterLocked = 0;
  78.  
  79. MASTER_LOCK(sema)
  80.     Sync_Semaphore    *sema;
  81. {
  82.     if (masterLocked) {
  83.     panic("MASTER_LOCK while lock held\n");
  84.     }
  85.     masterLocked = 1;
  86. }
  87. MASTER_UNLOCK(sema)
  88.     Sync_Semaphore    *sema;
  89. {
  90.     if (!masterLocked) {
  91.     panic("MASTER_UNLOCK while lock NOT held\n");
  92.     }
  93.     masterLocked = 0;
  94. }
  95.  
  96. void
  97. Dev_XbusHippiBuffer()
  98. {
  99. }
  100.  
  101. void
  102. Net_HppiLoopback(id, size, callbackProc, clientData)
  103.     int        id;
  104.     int        size;
  105.     void    (*callbackProc)();
  106.     ClientData    clientData;
  107. {
  108.     printf("Net_HppiLoopback: id=%d size=%d\n", id, size);
  109.     callbackProc(clientData, SUCCESS);
  110. }
  111.  
  112. void
  113. Dev_XbusXor(id, destBuf, numBuf, bufs, size, callbackProc, clientData)
  114.     int        id;
  115.     int        destBuf;
  116.     int        numBuf;
  117.     int        bufs[];
  118.     int        size;
  119.     void    (*callbackProc)();
  120.     ClientData    clientData;
  121. {
  122.     int i;
  123.     printf("Dev_XbusXor: id=%d destBuf=%d numBuf=%d size=%d",
  124.         id, destBuf, numBuf, size);
  125.     printf(" bufs =");
  126.     for (i = 0; i < numBuf; i++) {
  127.     printf(" %d", bufs[i]);
  128.     }
  129.     printf("\n");
  130.     callbackProc(clientData, SUCCESS);
  131. }
  132.  
  133. void
  134. Raid_InitiateSimpleStripeIOs(id, operation, startSector, nthSector,
  135.     buffer, callbackProc, clientData, ctrlData)
  136.     int        id;
  137.     int        operation;
  138.     int        startSector;
  139.     int        nthSector;
  140.     int        buffer;
  141.     void    (*callbackProc)();
  142.     ClientData    clientData;
  143.     int        ctrlData;
  144. {
  145.     printf("Raid_InitiateSimpleStripeIOs: id=%d operation=%d startSector=%d nthSector=%d buffer=%d\n", id, operation, startSector, nthSector, buffer);
  146.     callbackProc(clientData, SUCCESS);
  147. }
  148.  
  149. #endif TESTING
  150.  
  151.  
  152. static void
  153. Net_HppiIO(id, fromBuf, toBuf, size, callbackProc, clientData)
  154.     int        id;
  155.     int        fromBuf, toBuf;
  156.     int        size;
  157.     void    (*callbackProc)();
  158.     ClientData    clientData;
  159. {
  160.     ReturnStatus status;
  161.     extern void    Net_HppiLoopback();
  162.     extern void    Net_HppiSrcPattern();
  163.     
  164.     if (devXbusDebug) {
  165.     printf("Net_HppiIO(%d,%x,%x,%d,%x,%x)\n",
  166.         id, fromBuf, toBuf, size, callbackProc, clientData);
  167.     }
  168.     status = Dev_XbusHippiBuffer(xbusID, 1, size, fromBuf);
  169.     if (devXbusDebug) {
  170.     printf("Dev_XbusHippiBuffer(%d,%d,%d,%x)\n", id, 1, size, fromBuf);
  171.     }
  172.     if (status != SUCCESS) {
  173.     printf("ERROR: Dev_XbusHippiBuffer(1) failed, status=%x\n", status);
  174.     }
  175.     status = Dev_XbusHippiBuffer(xbusID, -1, size, toBuf);
  176.     if (status != SUCCESS) {
  177.     printf("ERROR: Dev_XbusHippiBuffer(-1) failed, status=%x\n", status);
  178.     }
  179.     if (devXbusDebug) {
  180.     printf("Dev_XbusHippiBuffer(%d,%d,%d,%x)\n", id, -1, size, toBuf);
  181.     }
  182.     Net_HppiLoopback(id, size, callbackProc, clientData);
  183. }
  184.  
  185. static void
  186. MyHppiIO(reqID)
  187.     int        reqID;
  188. {
  189.     if (devXbusDebug) {
  190.     printf("MyHppiIO(%d)\n", reqID);
  191.     }
  192.     MASTER_LOCK(&hppiMutex);
  193.     if (numInHppiQueue == 1000) {
  194.     MASTER_UNLOCK(&hppiMutex);
  195.     panic("MyHppiIO queue full.\n");
  196.     }
  197.     hppiQueue[numInHppiQueue++] = reqID;
  198.     if (!hppiInUse) {
  199.     hppiInUse = 1;
  200.     reqID = hppiQueue[--numInHppiQueue];
  201.     MASTER_UNLOCK(&hppiMutex);
  202.     Net_HppiIO(hppiID,
  203.         DataAddress(reqID),DataAddress((reqID-1+numBuf)%numBuf),
  204.         dataBufSize, myHppiCallback, reqID);
  205.     } else {
  206.     MASTER_UNLOCK(&hppiMutex);
  207.     }
  208. }
  209.  
  210. static void
  211. myHppiCallback(reqID, status)
  212.     int            reqID;
  213.     ReturnStatus    status;
  214. {
  215.     if (devXbusDebug) {
  216.     printf("myHppiCallback(%d,%x)\n", reqID, status);
  217.     }
  218.     MASTER_LOCK(&hppiMutex);
  219.     hppiInUse = 0;
  220.     if (numInHppiQueue > 0) {
  221.     int    newReqID;
  222.     hppiInUse = 1;
  223.     newReqID = hppiQueue[--numInHppiQueue];
  224.     MASTER_UNLOCK(&hppiMutex);
  225.     Net_HppiIO(hppiID,
  226.         DataAddress(newReqID), DataAddress((newReqID-1+numBuf)%numBuf),
  227.         dataBufSize, myHppiCallback, newReqID);
  228.     } else {
  229.     MASTER_UNLOCK(&hppiMutex);
  230.     }
  231.     hppiCallback(reqID, status);
  232. }
  233.  
  234.  
  235. static int    isEnd = 0;
  236. static int    maxNumReq;
  237.  
  238. void
  239. DevXbusTestStart(bufStartAddrArg, bufEndAddrArg, suSizeArg, numDiskArg,
  240.     maxNumReqArg)
  241.     int        bufStartAddrArg, bufEndAddrArg;
  242.     int        suSizeArg;
  243.     int        numDiskArg;
  244.     int        maxNumReqArg;
  245. {
  246.     int        reqID;
  247.  
  248.     printf("DevXbusTestStart: bufStartAddr=0x%x bufEndAddr=0x%x suSize=%d numDisk=%d, maxNumReq=%d\n", bufStartAddrArg, bufEndAddrArg, suSizeArg, numDiskArg, maxNumReqArg);
  249.  
  250.     numInHppiQueue = 0;
  251.     hppiInUse = 0;
  252.     hppiQueued = 0;
  253.     xorQueued = 0;
  254.     diskQueued = 0;
  255.     numReq = 0;
  256.     isEnd = 0;
  257.  
  258.     bufStartAddr = bufStartAddrArg;
  259.     bufEndAddr = bufEndAddrArg;
  260.     suSize = suSizeArg;
  261.     numDisk = numDiskArg;
  262.     maxNumReq = maxNumReqArg;
  263.     bufSize = suSize * numDisk;
  264.     dataBufSize = suSize * (numDisk -1);
  265.     numBuf = (bufEndAddr - bufStartAddr) / bufSize;
  266.     sectorsPerStripe = (suSize/512) * numDisk;
  267.  
  268.     for (reqID = 0; reqID < numBuf; reqID++) {
  269.     MASTER_LOCK(&mutex);
  270.     hppiQueued++;
  271.     MASTER_UNLOCK(&mutex);
  272.     MyHppiIO(reqID);
  273.     }
  274. }
  275.  
  276. void
  277. DevXbusTestStop()
  278. {
  279.     isEnd = 1;
  280. }
  281.  
  282. void
  283. DevXbusTestStat(buf)
  284.     char    *buf;
  285. {
  286.     sprintf(buf, "DevXbusTest: maxNumReq=%d numReq=%d hppiInUse=%d hppiQueued=%d xorQueued=%d diskQueued=%d\n", maxNumReq, numReq, hppiInUse, hppiQueued, xorQueued, diskQueued);
  287. }
  288.  
  289.  
  290. static void
  291. hppiCallback(reqID, status)
  292.     int            reqID;
  293.     ReturnStatus    status;
  294. {
  295.     int            buf[20];
  296.     int            suID;
  297.  
  298.     if (devXbusDebug) {
  299.     printf("hppiCallback(%d,%x)\n", reqID, status);
  300.     }
  301.     if (status != SUCCESS) {
  302.     printf("ERROR: hppi request %d failed, status=0x%x\n", reqID, status);
  303.     }
  304.     MASTER_LOCK(&mutex);
  305.     hppiQueued--;
  306.     xorQueued++;
  307.     MASTER_UNLOCK(&mutex);
  308.     for (suID = 0; suID < numDisk-1; suID++) {
  309.     buf[suID] = DataAddress(reqID) + suID * suSize;
  310.     }
  311.     Dev_XbusXor(xbusID, ParityAddress(reqID), numDisk-1, buf, suSize,
  312.         xorCallback, (ClientData) reqID);
  313. }
  314.  
  315. static void
  316. xorCallback(reqID, status)
  317.     int            reqID;
  318.     ReturnStatus    status;
  319. {
  320.     extern int        raidArray[];
  321.     extern void        Raid_InitiateSimpleStripeIOs();
  322.  
  323.     if (devXbusDebug) {
  324.     printf("xorCallback(%d,%x)\n", reqID, status);
  325.     }
  326.     if (status != SUCCESS) {
  327.     printf("ERROR: xor request %d failed, status=0x%x\n", reqID, status);
  328.     }
  329.     MASTER_LOCK(&mutex);
  330.     xorQueued--;
  331.     diskQueued++;
  332.     MASTER_UNLOCK(&mutex);
  333.     Raid_InitiateSimpleStripeIOs(&raidArray[0], FS_WRITE,
  334.         reqID * sectorsPerStripe, (reqID+1) * sectorsPerStripe,
  335.         DataAddress(reqID), diskCallback, reqID, 0);
  336. }
  337.  
  338. static void
  339. diskCallback(reqID, status)
  340.     int            reqID;
  341.     ReturnStatus    status;
  342. {
  343.     if (devXbusDebug) {
  344.     printf("diskCallback(%d,%x)\n", reqID, status);
  345.     }
  346.     if (status != SUCCESS) {
  347.     printf("ERROR: disk request %d failed, status=0x%x\n", reqID, status);
  348.     }
  349.     MASTER_LOCK(&mutex);
  350.     numReq++;
  351.     if (numReq >= maxNumReq) {
  352.     isEnd = 1;
  353.     }
  354.     diskQueued--;
  355.     if (!isEnd) {
  356.     hppiQueued++;
  357.     }
  358.     MASTER_UNLOCK(&mutex);
  359.     if (!isEnd) {
  360.     MyHppiIO(reqID);
  361.     }
  362.     if (numReq >= maxNumReq) {
  363.     printf("Ending test, numReq=%d\n", numReq);
  364.     }
  365. }
  366.  
  367. #ifdef TESTING
  368. main()
  369. {
  370.     DevXbusTestStart(8, 512000, 1024, 10);
  371. }
  372. #endif
  373.